home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 242 / Issue 242 - April 2008 - DPCS0408DVD.ISO / Software Money Savers / VirtualDub / Source / VirtualDub-1.7.7-src.7z / src / Priss / source / engine.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2007-10-13  |  7.8 KB  |  309 lines
  1. //    Priss (NekoAmp 2.0) - MPEG-1/2 audio decoding library
  2. //    Copyright (C) 2003 Avery Lee
  3. //
  4. //    This program is free software; you can redistribute it and/or modify
  5. //    it under the terms of the GNU General Public License as published by
  6. //    the Free Software Foundation; either version 2 of the License, or
  7. //    (at your option) any later version.
  8. //
  9. //    This program is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. //    GNU General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU General Public License
  15. //    along with this program; if not, write to the Free Software
  16. //    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #include <math.h>
  19. #include <vd2/system/vdtypes.h>
  20.  
  21. #include "engine.h"
  22.  
  23. extern IAMPDecoder * __cdecl CreateAMPDecoder() {
  24.     return new VDMPEGAudioDecoder;
  25. }
  26.  
  27. VDMPEGAudioDecoder::VDMPEGAudioDecoder()
  28.     : mpSource(NULL)
  29.     , mpPolyphaseFilter(NULL)
  30. {
  31. }
  32.  
  33. VDMPEGAudioDecoder::~VDMPEGAudioDecoder() {
  34.     delete mpPolyphaseFilter;
  35. }
  36.  
  37. void VDMPEGAudioDecoder::Destroy() {
  38.     delete this;
  39. }
  40.  
  41. char *VDMPEGAudioDecoder::GetAmpVersionString() {
  42.     return "NekoAmp 2.0 (Priss)";
  43. }
  44.  
  45. void VDMPEGAudioDecoder::Init() {
  46.     unsigned i,j;
  47.  
  48.     // layer II initialization
  49.  
  50.     for(i=0; i<64; ++i)
  51.         mL2Scalefactors[i] = (float)(2.0 / pow(2.0, i/3.0));
  52.  
  53.     for(i=0; i<32; ++i) {
  54.         mL2Ungroup3[i][0] = (i % 3) - 1;
  55.         mL2Ungroup3[i][1] = ((i / 3) % 3) - 1;
  56.         mL2Ungroup3[i][2] = ((i / 9) % 3) - 1;
  57.     }
  58.  
  59.     // layer III initialization
  60.  
  61.     for(i=0; i<36; ++i)
  62.         mL3Windows[0][i] = (float)sin((3.1415926535897932/36.0)*(i+0.5));
  63.  
  64.     for(i=0; i<18; ++i) {
  65.         mL3Windows[1][i] = (float)sin((3.1415926535897932/36.0)*(i+0.5));
  66.         mL3Windows[3][i+18] = (float)sin((3.1415926535897932/36.0)*(i+18+0.5));
  67.     }
  68.  
  69.     for(i=0; i<6; ++i) {
  70.         mL3Windows[1][i+18] = 1.0f;
  71.         mL3Windows[1][i+24] = (float)sin((3.1415926535897932/12.0)*(i+6+0.5));
  72.         mL3Windows[1][i+30] = 0.0f;
  73.  
  74.         mL3Windows[3][i] = 0.0f;
  75.         mL3Windows[3][i+6] = (float)sin((3.1415926535897932/12.0)*(i+0.5));
  76.         mL3Windows[3][i+12] = 1.0f;
  77.     }
  78.  
  79.     for(i=0; i<12; ++i) {
  80.         mL3Windows[2][i] = (float)sin((3.1415926535897932/12.0)*(i+0.5));
  81.     }
  82.  
  83. #if 1
  84.         static const float coeff_idct_to_imdct[18]={        // 1/[2 cos (pi/72)(2i+1)]
  85.             0.50047634258166f,
  86.             0.50431448029008f,
  87.             0.51213975715725f,
  88.             0.52426456257041f,
  89.             0.54119610014620f,
  90.             0.56369097343317f,
  91.             0.59284452371708f,
  92.             0.63023620700513f,
  93.             0.67817085245463f,
  94.             0.74009361646113f,
  95.             0.82133981585229f,
  96.             0.93057949835179f,
  97.             1.08284028510010f,
  98.             1.30656296487638f,
  99.             1.66275476171152f,
  100.             2.31011315767265f,
  101.             3.83064878777019f,
  102.             11.46279281302667f,
  103.         };
  104.  
  105.     for(j=0; j<4; ++j) {
  106.         if (j==2)
  107.             continue;
  108.         for(i=0; i<9; ++i) {
  109.             mL3Windows[j][i] *= coeff_idct_to_imdct[i+9];
  110.             mL3Windows[j][i+9] *= coeff_idct_to_imdct[17-i];
  111.             mL3Windows[j][i+18] *= -coeff_idct_to_imdct[8-i];
  112.             mL3Windows[j][i+27] *= -coeff_idct_to_imdct[i];
  113.         }
  114.     }
  115. #endif
  116. }
  117.  
  118. void VDMPEGAudioDecoder::setSource(IAMPBitsource *pSource) {
  119.     mpSource = pSource;
  120. }
  121.  
  122. void VDMPEGAudioDecoder::setDestination(short *psDest) {
  123.     mpSampleDst = psDest;
  124. }
  125.  
  126. long VDMPEGAudioDecoder::getSampleCount() {
  127.     return mSamplesDecoded;
  128. }
  129.  
  130. void VDMPEGAudioDecoder::getStreamInfo(AMPStreamInfo *pasi) {
  131.     *pasi = mHeader;
  132. }
  133.  
  134. char *VDMPEGAudioDecoder::getErrorString(int err) {
  135.     switch(err) {
  136.     case ERR_NONE:                return "no error";
  137.     case ERR_EOF:                return "end of file";
  138.     case ERR_READ:                return "read error";
  139.     case ERR_MPEG25:            return "cannot decode MPEG-2.5 streams";
  140.     case ERR_FREEFORM:            return "cannot decode free-form streams";
  141.     case ERR_SYNC:                return "sync error";
  142.     case ERR_INTERNAL:            return "internal error";
  143.     case ERR_INCOMPLETEFRAME:    return "incomplete frame";
  144.     case ERR_INVALIDDATA:        return "invalid or out-of-spec data encountered";
  145.     default:                    return "unknown error code";
  146.     }
  147. }
  148.  
  149. void VDMPEGAudioDecoder::Reset() {
  150.     if (!mpPolyphaseFilter || mpPolyphaseFilter->ShouldRecreate()) {
  151.         delete mpPolyphaseFilter;
  152.         mpPolyphaseFilter = VDMPEGAudioPolyphaseFilter::Create();
  153.     }
  154.  
  155.     mpPolyphaseFilter->Reset();
  156.  
  157.     mL3BufferPos = 0;
  158.  
  159.     memset(mL3OverlapBuffer, 0, sizeof mL3OverlapBuffer);
  160. }
  161.  
  162. void VDMPEGAudioDecoder::ReadHeader() {
  163.     // syncword            12 bits        0000F0FF
  164.     // id                1 bit        00000800
  165.     // layer            2 bits        00000600
  166.     // protection        1 bit        00000100
  167.     // bitrate            4 bits        00F00000
  168.     // sampling rate    2 bits        000C0000
  169.     // padding            1 bit        00020000
  170.     // private bit        1 bit        00010000
  171.     // mode                2 bits        C0000000
  172.     // mode extension    2 bits        30000000
  173.     // copyright        1 bit        08000000
  174.     // original/copy    1 bit        04000000
  175.     // emphasis            2 bits        03000000
  176.  
  177.     union {
  178.         char    buf[4];
  179.         uint32    v;
  180.     } hdr;
  181.     int bytes = 0;
  182.  
  183.     for(;;) {
  184.         while(bytes < 4) {
  185.             int r = mpSource->read(hdr.buf+bytes, 4-bytes);
  186.             if (r<0)
  187.                 throw (int)ERR_READ;
  188.             else if (!r)
  189.                 throw (int)ERR_EOF;
  190.             bytes += r;
  191.         }
  192.  
  193.         if ((hdr.v & 0xe0ff) == 0xe0ff)
  194.             break;
  195.  
  196.         hdr.buf[0] = hdr.buf[1];
  197.         hdr.buf[1] = hdr.buf[2];
  198.         hdr.buf[2] = hdr.buf[3];
  199.         --bytes;
  200.     }
  201.  
  202.     // determine frame size
  203.  
  204.     static const int sBitrateTable[2][3][16]={
  205.         {
  206.             { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0 },    // MPEG-1 layer I
  207.             { 0, 32, 48, 56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384, 0 },    // MPEG-1 layer II
  208.             { 0, 32, 40, 48,  56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 0 },    // MPEG-1 layer III
  209.         },
  210.         {
  211.             { 0, 32, 48, 56,  64,  80,  96, 112, 128, 144, 160, 176, 192, 224, 256, 0 },    // MPEG-2 layer I
  212.             { 0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160, 0 },    // MPEG-2 layer II
  213.             { 0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160, 0 },    // MPEG-2 layer III
  214.         }
  215.     };
  216.  
  217.     static const int sFrequencyTable[2][4]={{44100,48000,32000,0}, {22050,24000,16000,0}};
  218.  
  219.     bool is_mpeg2    = (hdr.v & 0x800) == 0;
  220.     bool is_mpeg25    = (hdr.v & 0x1000) == 0;
  221.     int layer        = 4 - ((hdr.v>>9)&3);
  222.     int bitrate_idx    = (hdr.v>>20)&15;
  223.     int freq_idx    = (hdr.v>>18)&3;
  224.     int padding        = (hdr.v>>17)&1;
  225.     int bitrate        = sBitrateTable[is_mpeg2][layer-1][bitrate_idx];
  226.     int freq        = sFrequencyTable[is_mpeg2][freq_idx];
  227.  
  228.     if (is_mpeg25)
  229.         freq >>= 1;
  230.  
  231.     mHeader.fStereo            = ((hdr.v>>30)&3) != 3;
  232.     mHeader.lBitrate        = bitrate;
  233.     mHeader.lSamplingFreq    = freq;
  234.     mHeader.nLayer            = layer;
  235.     mHeader.nMPEGVer        = (hdr.v & 0x800) != 0 ? 1 : 2;
  236.  
  237.     if (!bitrate_idx)
  238.         throw (int)ERR_FREEFORM;
  239.  
  240.     if (!freq)
  241.         throw (int)ERR_INVALIDDATA;
  242.  
  243.     if (layer == 1)
  244.         mFrameDataSize = 4*(12000*bitrate/freq + padding);
  245.     else {
  246.         if (is_mpeg2)
  247.             mFrameDataSize = (72000*bitrate/freq + padding);
  248.         else
  249.             mFrameDataSize = (144000*bitrate/freq + padding);
  250.     }
  251.  
  252.     // take off header size
  253.     mFrameDataSize -= 4;
  254.  
  255.     // read CRC
  256.     if (!(hdr.v&0x100)) {
  257.         char crc[2];
  258.  
  259.         int r = mpSource->read(crc, 2);
  260.         if (r < 0)
  261.             throw (int)ERR_READ;
  262.         else if (r < 2)
  263.             throw (int)ERR_EOF;
  264.  
  265.         mFrameDataSize -= 2;
  266.     }
  267.  
  268.     mBitrateIndex        = bitrate_idx;
  269.     mSamplingRateIndex    = freq_idx;
  270.     mMode            = (hdr.v>>30)&3;
  271.     mModeExtension    = (hdr.v>>28)&3;
  272. }
  273.  
  274. void VDMPEGAudioDecoder::PrereadFrame() {
  275.     int r = mpSource->read(mFrameBuffer, mFrameDataSize);
  276.  
  277.     if (r < (int)mFrameDataSize) {
  278.         if (r < 0)
  279.             throw (int)ERR_READ;
  280.         else
  281.             throw (int)ERR_INCOMPLETEFRAME;
  282.     }
  283.  
  284.     if (mHeader.nLayer == 3)
  285.         PrereadLayerIII();
  286. }
  287.  
  288. bool VDMPEGAudioDecoder::DecodeFrame() {
  289.     mSamplesDecoded = NULL;
  290.  
  291.     PrereadFrame();
  292.  
  293.     switch(mHeader.nLayer) {
  294.     case 1:
  295.         return DecodeLayerI();
  296.     case 2:
  297.         return DecodeLayerII();
  298.     case 3:
  299.         return DecodeLayerIII();
  300.     }
  301.  
  302.     return false;
  303. }
  304.  
  305. void VDMPEGAudioDecoder::ConcealFrame() {
  306.     mpPolyphaseFilter->Reset();
  307.     memset(mL3OverlapBuffer, 0, sizeof mL3OverlapBuffer);
  308. }
  309.